package ajedrez;

/**
 *
 * @author Marco
 */
public class tablero {

    int[][] tablero;

    
        public tablero(int[][] tablero) {
        this.tablero = new int[8][8];
          for (int x = 0; x < 8; x++)
            for (int y = 0; y < 8; y++)
                this.tablero[x][y]=tablero[x][y];

    }

    

    public tablero() {
        tablero = new int[][]{
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {1, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0, 0, 0, 0}
                };
    }

    /**
     * Mueve una pieza dentro del tablero.
     * @param fila_actual Fila actual de la ficha.
     * @param columna_actual Columna actual de la ficha.
     * @param nueva_fila La nueva fila de la ficha.
     * @param nueva_columna La nueva columna de la ficha.
     * @return Un arreglo de dos posiciones.
     * @return En la posicion 0, devuelve -1 si no es una jugada valida, 0 si lo es.
     * @return En la posicion 1, devuelve el valor de la jugada.
     */
    public int[] mover(int fila_actual, int columna_actual, int nueva_fila, int nueva_columna) {

        int retorno[] = new int[2];
        try {
            int ficha_actual = tablero[fila_actual][columna_actual];
            int ficha_nueva = tablero[nueva_fila][nueva_columna];

            //FALTA CUANDO SE CONVIERTE EN OTRA FICHA Y EL ENROQUE
            //DIAGONAL A LA IZQ
            if (ficha_actual == 1) //peon
            {
                if (ficha_nueva == 0) {//La posición esta vacia
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                }

                if (ficha_nueva != 0) {
                    try {
                        int ficha_diagonal = tablero[nueva_fila][nueva_columna + 1];
                        if (ficha_diagonal >= 0) {
                            retorno[0] = -1;
                        } else {
                            tablero[nueva_fila][nueva_columna + 1] = ficha_actual;
                            tablero[fila_actual][columna_actual] = 0;
                            retorno[0] = 1;
                        }

                    } catch (Exception e2) {
                        retorno[0] = -1;
                    }

                }

            } else if (ficha_actual == 2) {
                if (ficha_nueva > 0) {
                    retorno[0] = -1;
                } else {
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                }
            } else if (ficha_actual == 3) {
                if (ficha_nueva <= 0) {
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                } else {
                    retorno[0] = -1;
                }
            } else if (ficha_actual == 4) {

                if (ficha_nueva <= 0) {
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                } else {
                    retorno[0] = -1;
                }
            } else if (ficha_actual == 5) {
                if (ficha_nueva <= 0) {
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                } else {
                    retorno[0] = -1;
                }
            } else if (ficha_actual == 6) {
                // do something
                if (ficha_nueva <= 0) {
                    tablero[nueva_fila][nueva_columna] = ficha_actual;
                    tablero[fila_actual][columna_actual] = 0;
                    retorno[0] = 1;
                } else {
                    retorno[0] = -1;
                }
            }




        } catch (Exception e) {
            retorno[0] = -1;
        }

        return retorno;
    }

    /**
     * Se utiliza para devolver una ficha en una posicion determinada.
     * @param x La fila
     * @param y La columna
     * @return El valor de la ficha en la posición indicada
     * @return -1 si el valor indicado se encuentra fuera del rango
     */
    public int obtener_ficha(int x, int y) {

        int retorno = -1;
        try {
            retorno = tablero[x][y];
        } catch (Exception e) {
        }
        return retorno;
    }

    /**
     * Calcula el valor de una jugada basado en el tablero actual.
     * @return
     */
    public int valor_jugada() {
        int rey = 100;
        int dama = 9;
        int torre = 5;
        int alfil = 4;
        int caballo = 3;
        int peon = 2;
        int Nr = 0, Nd = 0, Nt = 0, Na = 0, Nc = 0, Np = 0, Nre = 0, Nde = 0, Nte = 0, Nae = 0, Nce = 0, Npe = 0;

        for (int x = 0; x < 8; x++) {
            for (int y = 0; y < 8; y++) {
                int f = tablero[x][y];
                if (f != 0) {

                        if (f == 1) {
                            Np++;
                        } else if (f == 2) {
                            Nc++;
                        } else if (f == 3) {
                            Na++;
                        } else if (f == 4) {
                            Nt++;
                        } else if (f == 5) {
                            Nd++;
                        } else if (f == 6) {
                            Nr++;
                        } else if (f == -1) {
                            Npe++;
                        } else if (f == -2) {
                            Nce++;
                        } else if (f == -3) {
                            Nae++;
                        } else if (f == -4) {
                            Nte++;
                        } else if (f == -5) {
                            Nde++;
                        } else if (f == -6) {
                            Nre++;
                        }



                }
            }
        }


        return ((Nr * rey + Nd * dama + Nt * torre + Na * alfil + Nc * caballo + Np * peon)
                - (Nre * rey + Nde * dama + Nte * torre + Nae * alfil + Nce * caballo + Npe * peon));

    }

    /**
     * Invierte los valores del tablero.
     */
    public void invertir(){
        for (int x = 0; x < 8; x++)
            for (int y = 0; y < 8; y++)
                 tablero[x][y]=tablero[x][y]*-1;
    }
    public void imprimir() {

        for (int x = 0; x < 8; x++) {
            for (int y = 0; y < 8; y++) {
                System.out.print(tablero[x][y]);
            }
            System.out.println();
        }

    }
}
